名域 ts {
    导出 名域 调试_ {
        变量 isDebugInfoEnabled = 为假;

        导出 常量 failBadSyntaxKind = 应该断言(断言等级_.普通_)
            ? (n: 节点_, 消息?: 文字): 不及 => 失败(
                `${消息 || 'Unexpected n.'}设置超时r\nNode ${formatSyntaxKind(n.种类)} was unexpected.`,
                failBadSyntaxKind)
            : 什么都不做 转为 () => 不及; // TODO: GH#22091

        导出 常量 assertEachNode = 应该断言(断言等级_.普通_)
            ? (nodes: 节点_[], test: (n: 节点_) => 真假, 消息?: 文字): 无值 => 断言(
                test === 未定 || every(nodes, test),
                消息 || 'Unexpected n.',
                () => `节点_ 数组 did not pass test '${getFunctionName(test)}'.`,
                assertEachNode)
            : 什么都不做;

        导出 常量 assertNode = 应该断言(断言等级_.普通_)
            ? (n: 节点_, test: (n: 节点_) => 真假, 消息?: 文字): 无值 => 断言(
                test === 未定 || test(n),
                消息 || 'Unexpected n.',
                () => `节点_ ${formatSyntaxKind(n.种类)} did not pass test '${getFunctionName(test)}'.`,
                assertNode)
            : 什么都不做;

        导出 常量 assertOptionalNode = 应该断言(断言等级_.普通_)
            ? (n: 节点_, test: (n: 节点_) => 真假, 消息?: 文字): 无值 => 断言(
                test === 未定 || n === 未定 || test(n),
                消息 || 'Unexpected n.',
                () => `节点_ ${formatSyntaxKind(n.种类)} did not pass test '${getFunctionName(test)}'.`,
                assertOptionalNode)
            : 什么都不做;

        导出 常量 assertOptionalToken = 应该断言(断言等级_.普通_)
            ? (n: 节点_, 种类: 语法_, 消息?: 文字): 无值 => 断言(
                种类 === 未定 || n === 未定 || n.种类 === 种类,
                消息 || 'Unexpected n.',
                () => `节点_ ${formatSyntaxKind(n.种类)} was not a '${formatSyntaxKind(种类)}' 令牌.`,
                assertOptionalToken)
            : 什么都不做;

        导出 常量 assertMissingNode = 应该断言(断言等级_.普通_)
            ? (n: 节点_, 消息?: 文字): 无值 => 断言(
                n === 未定,
                消息 || 'Unexpected n.',
                () => `节点_ ${formatSyntaxKind(n.种类)} was unexpected'.`,
                assertMissingNode)
            : 什么都不做;

        /**
         * Injects debug information into frequently used 类型组.
         */
        导出 函数 启用调试信息() {
            如果 (isDebugInfoEnabled) 返回;

            // Add additional 属性组 in debug mode to assist with debugging.
            实例_.定义属性组(对象分配器.获取符号构造器().原型, {
                _调试标志: { 获取(this: 符号_) { 返回 formatSymbolFlags(本体.标志); } }
            });

            实例_.定义属性组(对象分配器.获取类型构造器().原型, {
                _调试标志: { 获取(this: 类型_) { 返回 formatTypeFlags(本体.标志); } },
                _调试对象标志: { 获取(this: 类型_) { 返回 本体.标志 & 类型标志_.对象_ ? formatObjectFlags((<对象类型_>本体).对象标志) : ''; } },
                _调试类型转文本: { 值(this: 类型_) { 返回 本体.检查者.typeToString(本体); } },
            });

            常量 nodeConstructors = [
                对象分配器.获取节点构造器(),
                对象分配器.获取标识符构造器(),
                对象分配器.获取令牌构造器(),
                对象分配器.获取源文件构造器()
            ];

            循环 (常量 ctor 属于 nodeConstructors) {
                如果 (!ctor.原型.hasOwnProperty('_调试种类')) {
                    实例_.定义属性组(ctor.原型, {
                        _调试种类: { 获取(this: 节点_) { 返回 formatSyntaxKind(本体.种类); } },
                        _调试修饰符种类: { 获取(this: 节点_) { 返回 formatModifierFlags(getModifierFlagsNoCache(本体)); } },                        
                        _调试输出标志: { 获取(this: 节点_) { 返回 formatEmitFlags(getEmitFlags(本体)!); } },
                        _调试获取文本: {
                            值(this: 节点_, 包含杂项?: 真假) {
                                如果 (节点是合成的(本体)) 返回 '';
                                常量 parseNode = 获取解析树节点(本体);
                                常量 源文件 = parseNode && 获取节点的源文件(parseNode);
                                返回 源文件 ? 获取源文件节点的源文本(源文件, parseNode, 包含杂项) : '';
                            }
                        }
                    });
                }
            }

            isDebugInfoEnabled = 为真;
        }
    }
}